C++ Primer, Fifth Edition: Identity vs. Value: Understanding Lvalues and Rvalues

In C++, every expression results in either an lvalue or an rvalue. This distinction defines whether an expression refers to an object’s identity (where it is) or its value (what it contains).

1. Identity vs. Contents

An lvalue (locator value) represents an object with a persistent memory address. Think of it as a labeled box in RAM. Conversely, an rvalue (read value) is transient; it represents a temporary result or a literal that does not have an address accessible to the programmer.

2. Functional Transitions

While an lvalue can act as an rvalue (the compiler simply fetches the value inside the box), the reverse is forbidden. You cannot use an rvalue where an lvalue is required—for instance, you cannot take the address of a literal number like &42 because it lacks a persistent identity.

$$ \text{Lvalue} \xrightarrow{\text{Conversion}} \text{Rvalue} \quad (\text{Allowed}) $$

$$ \text{Rvalue} \xrightarrow{\text{Assignment}} \text{Lvalue} \quad (\text{Forbidden}) $$

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

Which of the following best describes an lvalue?

A temporary result of a calculation.

An expression that yields an object with a persistent memory identity.

A literal constant like 3.14.

Any value that appears on the right side of an assignment.

QUESTION 2

In the expression dval = ival = 0;, why is 0 considered an rvalue?

Because it is an integer.

Because it is on the far right of the expression.

Because it is a literal constant with no persistent memory address.

Because it is assigned to pi.

QUESTION 3

True or False: You can use an rvalue where an lvalue is required.

True

False

QUESTION 4

What happens when you use an lvalue in a context that requires an rvalue?

A compile-time error occurs.

The compiler performs an lvalue-to-rvalue conversion.

The memory address of the lvalue is used as the value.

The lvalue is deleted from memory.

QUESTION 5

Which of these expressions is an lvalue?

42

x + y (where x and y are ints)

std::string("hello")

A variable name like myVar

Comprehensive Expression Analysis

Applying Lvalue/Rvalue theory to Exercise 5.23 and 4.2

As a C++ developer, you must evaluate how expressions are grouped and whether their operands are valid based on their identity and value types. Consider the following definitions: int i; double d; const string *ps; char *pc; void *pv; vector<int> vec = {10, 20};

1. [Exercise 5.23] Provide a program that safely reads two integers and prints the result of their division. What role do lvalues play here?

Solution:
Model Solution: cpp int n1, n2; if (std::cin >> n1 >> n2) { if (n2 != 0) std::cout << n1 / n2 << std::endl; else std::cerr << "Division by zero!" << std::endl; } In this program, `n1` and `n2` are lvalues used to store input. In the expression `n1 / n2`, they undergo lvalue-to-rvalue conversion to provide their contents for the arithmetic operation.

2. [Exercise 4.2] Parenthesize the expressions `* vec.begin()` and `* vec.begin() + 1`. Identify which parts are lvalues.

Solution:
Parenthesization: (a) `*(vec.begin())`: The `.` operator has higher precedence than `*`. `vec.begin()` returns an iterator (rvalue), and dereferencing it yields an lvalue (the first element of the vector). (b) `(*(vec.begin())) + 1`: The addition occurs after dereferencing. The result of the addition is an rvalue (a temporary numerical result).

3. [Theory Depth] Why does `&42` fail while `&ival` succeeds?

Solution:
The address-of operator (`&`) requires an lvalue operand. `42` is a literal rvalue with no persistent location in memory to point to. `ival` is an lvalue representing a specific, identifiable memory address, so the operator can successfully return that address.